/**
 * @file vm.h
 * @brief VimL虚拟机核心实现
 * @author VimLVM Team
 * @date 2025
 */

#ifndef VIML_VM_H
#define VIML_VM_H

#include "common.h"
#include "instruction.h"
#include "value.h"
#include <stack>
#include <unordered_map>
#include <unordered_set>

namespace viml {
    struct Function;  // 前向声明

// 调用帧
struct CallFrame {
    std::shared_ptr<Function> function;
    size_t pc;              // 程序计数器
    size_t base;            // 寄存器基址
    std::vector<Value> registers;
    
    CallFrame(std::shared_ptr<Function> func, size_t reg_base)
        : function(std::move(func)), pc(0), base(reg_base) {
        registers.resize(function->locals_count + MAX_REGISTERS);
    }
};

// 虚拟机状态
enum class VMState {
    READY,
    RUNNING,
    PAUSED,
    ERROR,
    HALTED
};

// 调试钩子
class DebugHook {
public:
    virtual ~DebugHook() = default;
    virtual void on_breakpoint(size_t line) = 0;
    virtual void on_step(size_t line) = 0;
    virtual void on_error(const std::string& error) = 0;
};

class VM {
public:
    VM();
    ~VM();

    // 执行控制
    ErrorCode execute(std::shared_ptr<Function> function);
    void halt();
    void pause();
    void resume();
    
    // 调试接口
    void set_debug_hook(std::unique_ptr<DebugHook> hook);
    void add_breakpoint(size_t line);
    void remove_breakpoint(size_t line);
    void step();
    void step_over();
    void step_out();
    
    // 状态查询
    VMState state() const { return state_; }
    size_t current_line() const;
    std::string current_function() const;
    
    // 变量访问
    Value get_global(const std::string& name) const;
    void set_global(const std::string& name, const Value& value);
    std::unordered_map<std::string, Value> get_all_globals() const;
    
    Value get_local(const std::string& name) const;
    void set_local(const std::string& name, const Value& value);
    
    // 调用栈信息
    struct StackFrame {
        std::string function_name;
        size_t line;
        std::unordered_map<std::string, Value> locals;
    };
    
    std::vector<StackFrame> call_stack() const;
    
    // 错误信息
    std::string last_error() const { return last_error_; }

private:
    VMState state_;
    std::string last_error_;
    
    // 执行栈
    std::vector<CallFrame> frames_;
    std::vector<Value> stack_;
    
    // 全局变量
    std::unordered_map<std::string, Value> globals_;
    
    // 调试信息
    std::unique_ptr<DebugHook> debug_hook_;
    std::unordered_set<size_t> breakpoints_;
    bool single_step_mode_;
    
    // 执行核心
    ErrorCode run();
    ErrorCode execute_instruction(const Instruction& inst);
    
    // 寄存器操作
    Value& get_register(uint8_t reg);
    const Value& get_register(uint8_t reg) const;
    
    // 辅助函数
    void push_frame(std::shared_ptr<Function> function, size_t argc);
    void pop_frame();
    void push_value(const Value& value);
    Value pop_value();
    
    // 调试支持
    bool should_break() const;
    void notify_error(const std::string& error);
};

} // namespace viml

#endif // VIML_VM_H